
/*
 * Copyright 2011 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#include "SampleCode.h"
#include "SkView.h"
#include "SkCanvas.h"
#include "Sk64.h"
#include "SkGradientShader.h"
#include "SkGraphics.h"
#include "SkImageDecoder.h"
#include "SkKernel33MaskFilter.h"
#include "SkPath.h"
#include "SkRandom.h"
#include "SkRegion.h"
#include "SkShader.h"
#include "SkUtils.h"
#include "SkColorPriv.h"
#include "SkColorFilter.h"
#include "SkTime.h"
#include "SkTypeface.h"
#include "SkXfermode.h"

#include "SkStream.h"
#include "SkXMLParser.h"

static const int gKernel[3][3] =
    {
//    { -1, -2, -1 }, { -2, 12, -2 }, { -1, -2, -1 }
        { 1, 2, 1 }, { 2, 64-12, 2 }, { 1, 2, 1 }
    };
static const int gShift = 6;

class ReduceNoise : public SkKernel33ProcMaskFilter
    {
    public:
        ReduceNoise(int percent256) : SkKernel33ProcMaskFilter(percent256) {}
        virtual uint8_t computeValue(uint8_t* const* srcRows)
            {
            int c = srcRows[1][1];
            int min = 255, max = 0;
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j++)
                    if (i != 1 || j != 1)
                        {
                        int v = srcRows[i][j];
                        if (max < v)
                            max = v;
                        if  (min > v)
                            min = v;
                        }
            if (c > max) c = max;
            //    if (c < min) c = min;
            return c;
            }
        virtual Factory getFactory()
            {
            return Create;
            }
    private:
        ReduceNoise(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
        static SkFlattenable* Create(SkFlattenableReadBuffer& rb)
            {
            return new ReduceNoise(rb);
            }
    };

class Darken : public SkKernel33ProcMaskFilter
    {
    public:
        Darken(int percent256) : SkKernel33ProcMaskFilter(percent256) {}
        virtual uint8_t computeValue(uint8_t* const* srcRows)
            {
            int c = srcRows[1][1];
            float f = c / 255.f;

            if (c >= 0)
                {
                f = sqrtf(f);
                }
            else
                {
                f *= f;
                }
            SkASSERT(f >= 0 && f <= 1);
            return (int)(f * 255);
            }
        virtual Factory getFactory()
            {
            return Create;
            }
    private:
        Darken(SkFlattenableReadBuffer& rb) : SkKernel33ProcMaskFilter(rb) {}
        static SkFlattenable* Create(SkFlattenableReadBuffer& rb)
            {
            return new Darken(rb);
            }
    };

static SkMaskFilter* makemf()
    {
    return new Darken(0x30);
    }

static void test_breakText()
    {
    SkPaint paint;
    const char* text = "sdfkljAKLDFJKEWkldfjlk#$%&sdfs.dsj";
    size_t length = strlen(text);
    SkScalar width = paint.measureText(text, length);

    SkScalar mm = 0;
    SkScalar nn = 0;
    for (SkScalar w = 0; w <= width; w += SK_Scalar1)
        {
        SkScalar m;
        size_t n = paint.breakText(text, length, w, &m,
                                   SkPaint::kBackward_TextBufferDirection);

        SkASSERT(n <= length);
        SkASSERT(m <= width);

        if (n == 0)
            {
            SkASSERT(m == 0);
            }
        else
            {
            // now assert that we're monotonic
            if (n == nn)
                {
                SkASSERT(m == mm);
                }
            else
                {
                SkASSERT(n > nn);
                SkASSERT(m > mm);
                }
            }
        nn = SkIntToScalar(n);
        mm = m;
        }

    SkDEBUGCODE(size_t length2 =) paint.breakText(text, length, width, &mm);
    SkASSERT(length2 == length);
    SkASSERT(mm == width);
    }

static SkRandom gRand;

class SkPowerMode : public SkXfermode
    {
    public:
        SkPowerMode(SkScalar exponent)
            {
            this->init(exponent);
            }

        virtual void xfer16(uint16_t dst[], const SkPMColor src[], int count,
                            const SkAlpha aa[]);

        typedef SkFlattenable* (*Factory)(SkFlattenableReadBuffer&);

        // overrides for SkFlattenable
        virtual Factory getFactory()
            {
            return Create;
            }
        virtual void flatten(SkFlattenableWriteBuffer& b)
            {
            //    this->INHERITED::flatten(b);  How can we know if this is legal????
            b.write32(SkScalarToFixed(fExp));
            }

    private:
        SkScalar fExp;          // user's value
        uint8_t fTable[256];    // cache

        void init(SkScalar exponent);
        SkPowerMode(SkFlattenableReadBuffer& b) : SkXfermode(b)
            {
            // read the exponent
            this->init(SkFixedToScalar(b.readS32()));
            }
        static SkFlattenable* Create(SkFlattenableReadBuffer& b)
            {
            return SkNEW_ARGS(SkPowerMode, (b));
            }

        typedef SkXfermode INHERITED;
    };

void SkPowerMode::init(SkScalar e)
    {
    fExp = e;
    float ee = SkScalarToFloat(e);

    printf("------ %g\n", ee);
    for (int i = 0; i < 256; i++)
        {
        float x = i / 255.f;
        //   printf(" %d %g", i, x);
        x = powf(x, ee);
        //   printf(" %g", x);
        int xx = SkScalarRound(SkFloatToScalar(x * 255));
        //   printf(" %d\n", xx);
        fTable[i] = SkToU8(xx);
        }
    }

void SkPowerMode::xfer16(uint16_t dst[], const SkPMColor src[], int count,
                         const SkAlpha aa[])
    {
    for (int i = 0; i < count; i++)
        {
        SkPMColor c = src[i];
        int r = SkGetPackedR32(c);
        int g = SkGetPackedG32(c);
        int b = SkGetPackedB32(c);
        r = fTable[r];
        g = fTable[g];
        b = fTable[b];
        dst[i] = SkPack888ToRGB16(r, g, b);
        }
    }

static const struct
    {
    const char* fName;
    uint32_t    fFlags;
    bool        fFlushCache;
    } gHints[] =
    {
        { "Linear", SkPaint::kLinearText_Flag,     false },
        { "Normal",   0,                           true },
        { "Subpixel", SkPaint::kSubpixelText_Flag, true }
    };

static int count_char_points(const SkPaint& paint, char c)
    {
    SkPath  path;

    paint.getTextPath(&c, 1, 0, 0, &path);
    return path.getPoints(NULL, 0);
    }

static int gOld, gNew, gCount;

static void dump(int c, int oldc, int newc)
    {
    if (oldc != newc)
        {
        gOld += oldc;
        gNew += newc;
        gCount += 1;
        printf("char %c: old = %3d, new = %3d, reduction %g%%\n", c, oldc, newc, 100. * (oldc - newc) / oldc);
        }
    }

static void tab(int n)
    {
//    printf("[%d] ", n); return;
    SkASSERT(n >= 0);
    for (int i = 0; i < n; i++)
        printf("    ");
    }

static void draw_rgn(const SkRegion& rgn, SkCanvas* canvas, const SkPaint& paint)
    {
    SkRect    r;
    SkRegion::Iterator  iter(rgn);

    for (; !iter.done(); iter.next())
        {
        r.set(iter.rect());
        canvas->drawRect(r, paint);
        }
    }

static void test_break(SkCanvas* canvas, const char text[], size_t length,
                       SkScalar x, SkScalar y, const SkPaint& paint,
                       SkScalar clickX)
    {
    SkPaint linePaint;

    linePaint.setAntiAlias(true);

    SkScalar measured;

    if (paint.breakText(text, length, clickX - x, &measured,
                        SkPaint::kForward_TextBufferDirection))
        {
        linePaint.setColor(SK_ColorRED);
        canvas->drawLine(x, y, x + measured, y, linePaint);
        }

    x += paint.measureText(text, length);
    if (paint.breakText(text, length, x - clickX, &measured,
                        SkPaint::kBackward_TextBufferDirection))
        {
        linePaint.setColor(SK_ColorBLUE);
        canvas->drawLine(x - measured, y, x, y, linePaint);
        }
    }

static void DrawTheText(SkCanvas* canvas, const char text[], size_t length,
                        SkScalar x, SkScalar y, const SkPaint& paint,
                        SkScalar clickX, SkMaskFilter* mf)
    {
    SkPaint p(paint);

#if 0
    canvas->drawText(text, length, x, y, paint);
#else
        {
        SkPoint pts[1000];
        SkScalar xpos = x;
        SkASSERT(length <= SK_ARRAY_COUNT(pts));
        for (size_t i = 0; i < length; i++)
            {
            pts[i].set(xpos, y), xpos += paint.getTextSize();
            }
        canvas->drawPosText(text, length, pts, paint);
        }
#endif

    p.setSubpixelText(true);
    x += SkIntToScalar(180);
    canvas->drawText(text, length, x, y, p);

#ifdef SK_DEBUG
    if (true)
        {
        //    p.setMaskFilter(mf);
        p.setSubpixelText(false);
        p.setLinearText(true);
        x += SkIntToScalar(180);
        canvas->drawText(text, length, x, y, p);
        }
#endif
    }

class TextSpeedView : public SampleView
    {
    public:
        TextSpeedView()
            {
            fMF = makemf();

            fHints = 0;
            fClickX = 0;

            test_breakText();
            }

        virtual ~TextSpeedView()
            {
            SkSafeUnref(fMF);
            }

    protected:
        // overrides from SkEventSink
        virtual bool onQuery(SkEvent* evt)
            {
            if (SampleCode::TitleQ(*evt))
                {
                SampleCode::TitleR(evt, "Text");
                return true;
                }
            return this->INHERITED::onQuery(evt);
            }

        static void make_textstrip(SkBitmap* bm)
            {
            bm->setConfig(SkBitmap::kRGB_565_Config, 200, 18);
            bm->allocPixels();
            bm->eraseColor(SK_ColorWHITE);

            SkCanvas    canvas(*bm);
            SkPaint     paint;
            const char* s = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit";

            paint.setFlags(paint.getFlags() | SkPaint::kAntiAlias_Flag
                           | SkPaint::kDevKernText_Flag);
            paint.setTextSize(SkIntToScalar(14));
            canvas.drawText(s, strlen(s), SkIntToScalar(8), SkIntToScalar(14), paint);
            }

        static void fill_pts(SkPoint pts[], size_t n, SkRandom* rand)
            {
            for (size_t i = 0; i < n; i++)
                pts[i].set(rand->nextUScalar1() * 640, rand->nextUScalar1() * 480);
            }

        virtual void onDrawContent(SkCanvas* canvas)
            {
            SkAutoCanvasRestore restore(canvas, false);
                {
                SkRect r;
                r.set(0, 0, SkIntToScalar(1000), SkIntToScalar(20));
                //     canvas->saveLayer(&r, NULL, SkCanvas::kHasAlphaLayer_SaveFlag);
                }

            SkPaint paint;
//        const uint16_t glyphs[] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 };
            int         index = fHints % SK_ARRAY_COUNT(gHints);
            index = 1;
//        const char* style = gHints[index].fName;

//        canvas->translate(0, SkIntToScalar(50));

            //      canvas->drawText(style, strlen(style), SkIntToScalar(20), SkIntToScalar(20), paint);

            SkSafeUnref(paint.setTypeface(SkTypeface::CreateFromFile("/skimages/samplefont.ttf")));
            paint.setAntiAlias(true);
            paint.setFlags(paint.getFlags() | gHints[index].fFlags);

            SkRect clip;
            clip.set(SkIntToScalar(25), SkIntToScalar(34), SkIntToScalar(88), SkIntToScalar(155));

            const char* text = "Hamburgefons";
            size_t length = strlen(text);

            SkScalar y = SkIntToScalar(0);
            for (int i = 9; i <= 24; i++)
                {
                paint.setTextSize(SkIntToScalar(i) /*+ (gRand.nextU() & 0xFFFF)*/);
                for (SkScalar dx = 0; dx <= SkIntToScalar(3)/4;
                        dx += SkIntToScalar(1) /* /4 */)
                    {
                    y += paint.getFontSpacing();
                    DrawTheText(canvas, text, length, SkIntToScalar(20) + dx, y,
                                paint, fClickX, fMF);
                    }
                }
            if (gHints[index].fFlushCache)
                {
//                SkGraphics::SetFontCacheUsed(0);
                }
            }

        virtual SkView::Click* onFindClickHandler(SkScalar x, SkScalar y)
            {
            fClickX = x;
            this->inval(NULL);
            return this->INHERITED::onFindClickHandler(x, y);
            }

        virtual bool onClick(Click* click)
            {
            return this->INHERITED::onClick(click);
            }

    private:
        int fHints;
        SkScalar fClickX;
        SkMaskFilter* fMF;

        typedef SampleView INHERITED;
    };

//////////////////////////////////////////////////////////////////////////////

static SkView* MyFactory()
    {
    return new TextSpeedView;
    }
static SkViewRegister reg(MyFactory);

